home *** CD-ROM | disk | FTP | other *** search
/ PC World Interactive 7 / PC World Interactive 7.iso / program / cprog.EXE / VIEW.C < prev    next >
C/C++ Source or Header  |  1995-10-02  |  24KB  |  1,031 lines
  1. #include <stdio.h>
  2. #include <fcntl.h>
  3. #include <sys\types.h>
  4. #include <sys\stat.h>
  5. #include <io.h>
  6. #include <share.h>
  7. #include <stdlib.h>
  8. #include <string.h>
  9. #include <dos.h>
  10. #include <share.h>
  11. #include <conio.h>
  12. #include <limits.h>
  13. #include <direct.h>
  14. #include "view.h"
  15.  
  16. /*
  17.   GLOBAL variable initialization 
  18. */
  19. VIEW *viewstack = NULL;                  /* pointer to the bottom view on screen */
  20.  
  21. UCHAR _far *screen;              /* pointer to display ram */
  22.  
  23. #if VIEW_HAS_MEMORY
  24.                                          /* huge 0 pointer to memory */
  25. UCHAR _huge *memory = (char _huge *)0;
  26. #endif
  27.                                          /* characters used in hex/dec conversion routines */
  28. UCHAR  hexdigits[] = {"0123456789ABCDEF"};
  29.  
  30. int view_offset   = 0;                   /* current offset into display memory */
  31. int view_attr     = 0;                   /* current display attribute */
  32. int view_is_mono  = FALSE;               /* flag indicates mono (TRUE) or color (FALSE) */
  33. int view_cols     = 80;
  34. int view_rows     = 25;
  35. UCHAR _far *bios_rows = (UCHAR _far *)0x00400084;
  36. UINT _far *bios_cols  = (UINT _far *)0x0040004A;
  37.  
  38. UCHAR *view_line   = NULL;                /* line input buffer */
  39.  
  40. #if VIEW_HAS_DIR
  41.  
  42. UCHAR *view_curdir = NULL;                /* current directory when view entered */
  43. UINT   view_curdrive = 0;
  44.  
  45. #endif
  46.  
  47. /*
  48.   Array of attributes for color and monochrome displays
  49. */
  50.  
  51. int view_attr_list[2][5] = {
  52.                              {     /* Color Attributes */
  53.                              0x1f, /* Active Window */
  54.                              0x30, /* Inactive Window */
  55.                              0x4f, /* Error Message */
  56.                              0x1b, /* Get a String  */
  57.                              0x31  /* Get a String Cursor */
  58.                              }, 
  59.                              {     /* Mono Attributes */
  60.                              0x0f, /* Active Window */
  61.                              0x70, /* Inactive Window */
  62.                              0x0f, /* Error Message */
  63.                              0x01, /* Get a String  */
  64.                              0x70  /* Get a String Cursor */
  65.                              }
  66.                            };
  67.  
  68. /*
  69.  
  70.    Function: main( int argc, UCHAR *argv[] )
  71.  
  72.    Description: 
  73.      This function will :
  74.  
  75.      1) close any "extra" file handles we inherited from
  76.      whoever ran us to give us more views
  77.  
  78.      2) save the current directory
  79.  
  80.      3) figure out whether we're in color or monochrome and set the
  81.      video buffer address in screen
  82.  
  83.      4) check the standard input to see if it's a file and
  84.      if so add it to the list of views and open a new standard
  85.      input.
  86.  
  87.      5) if we have no command line arguments prompt for file name
  88.  
  89.      6) process all command line arguments as if they were file names
  90.  
  91.      7) go into the view user interface and view files
  92.  
  93.      8) if we exit this way restore current directory
  94. */
  95.  
  96. main( int argc, UCHAR *argv[] )
  97. {
  98.   int i;
  99.   char fname[15];
  100.  
  101.   _harderr(view_errfunc);
  102.                                          /* Close "extra" file handles */
  103.   _dos_close(fileno(stderr));
  104.   _dos_close(fileno(stdaux));
  105.   _dos_close(fileno(stdprn));
  106.   _dos_close(fileno(stdout));
  107.                                          /* Assume :) that video mode 7 is monochrome */
  108.   if (view_getvidmode() == 7)
  109.     {
  110.     view_is_mono = TRUE;
  111.     screen = (UCHAR _far *)0xB0000000;
  112.     }
  113.   else
  114.     {
  115.     view_is_mono = FALSE;
  116.     screen = (UCHAR _far *)0xB8000000;
  117.     }
  118.  
  119.   view_rows = (*bios_rows)+1;
  120.   view_cols = (*bios_cols);
  121.                                          /* Save the current directory */
  122. #if VIEW_HAS_DIR
  123.   _dos_getdrive(&view_curdrive);
  124.   view_curdir = getcwd(NULL,80);
  125.   if (!view_curdir)
  126.     view_error(1,"VIEW0001");
  127. #endif
  128.                                          /* If stdin is a file then add it */
  129.   if (!isatty(fileno(stdin))) 
  130.     view_new(NULL,0,0,16,45);
  131.                                          /* If no args prompt for file */
  132.   if (argc <= 1 && !viewstack )
  133.     {
  134. #if VIEW_HAS_NEWFILE
  135.     view_newfile();
  136. #else
  137.     view_error(1,"[command |]VIEW [<filename] [filename .. filenameN]");
  138. #endif
  139.     }
  140.   else                                   /* process args as file names */
  141.     {
  142.     for (i = 1; i < argc; i ++)
  143.       view_new(argv[i],0,0,16,45);
  144.     }
  145.                                          /* put it on the screen and play */
  146.                                          /* with it */
  147.   view();
  148.  
  149. #if VIEW_HAS_DIR
  150.   if (view_curdir)                       /* return to saved dir and release memory */
  151.     {
  152.     _dos_setdrive(view_curdrive,&i);
  153.     chdir(view_curdir);
  154.     free(view_curdir);
  155.     }
  156. #endif
  157. }
  158. /*
  159.    Function: void view(void)
  160.  
  161.    Description:
  162.      This function puts up the user interface for view and accepts the
  163.      users input. It is basically a big switch on what key they hit. The
  164.      keys break down into extended and regular, extended keys are always
  165.      preceded by a null scan code.
  166.  
  167.      There are a set of offsets row_offset,col_offset etc... these are
  168.      set when certain keys are hit and are added to their corresponding
  169.      fields. The view_refresh routine enforces all dimensional constraints
  170.      so we don't worry about "overflow" or "underflow" in this routine.
  171.  
  172.      If page_offset is set to a non-zero value then the file is read 
  173.      either forwards or backwards abs(page_offset) times.
  174.  
  175.      The different refresh modes are used to speed up the screen update
  176.      when only the top window needs to be updated or only the top window's
  177.      contents.
  178. */
  179. void view(void)
  180. {
  181.   int c1;                                /* first character read */
  182.   int c2;                                /* second character read */
  183.   int row_offset;                        /* change row of window */
  184.   int col_offset;                        /* change col of window */
  185.   int height_offset;                     /* change height of window */
  186.   int width_offset;                      /* change width of window */
  187.   int line_offset;                       /* change coff of window */
  188.   int page_offset;                       /* change page of contents of window */
  189.   int refresh_mode;                      /* see refresh modes in view.h */
  190.   VIEW *top;                             /* temporary ptr to top window */
  191.  
  192.   if (!viewstack) return;                /* there aren't any views so return */
  193.  
  194.   if (!view_line)                        /* allocate the line buffer if NULL */
  195.     {
  196.     if (!(view_line = malloc(VIEW_MAX_LINE+1)))
  197.       view_error(1,"VIEW0002");
  198.     }
  199.  
  200.   view_tile();                           /* arrange the windows nicely */
  201.   top = viewstack;
  202.   do
  203.     {
  204.     view_scroll(top,SCROLL_RESET);
  205.     top = top->next;
  206.     }
  207.   while( top != viewstack );
  208.  
  209.   view_refresh(REFRESH_ALL);             /* put them on the screen */
  210.  
  211.  
  212.   for(;;)
  213.     {
  214.     refresh_mode = REFRESH_ALL;          /* reset change variables */
  215.     row_offset   = 0;
  216.     col_offset   = 0;
  217.     height_offset= 0;
  218.     width_offset = 0;
  219.     line_offset  = 0;
  220.     page_offset  = SCROLL_NONE;
  221.  
  222.     c1 = getch();                        /* get a keystroke from console */
  223.     
  224.     switch( c1 )                         /* select an action based on key */
  225.       {
  226.       case 0:                            /* an extended key follows */
  227.         c2 = getch();                    /* get extended keysroke */
  228.  
  229.         switch(c2)
  230.           {
  231.           case CURSOR_DOWN:
  232.             refresh_mode = REFRESH_CONTENTS;
  233.             page_offset = SCROLL_DOWN;
  234.           break;
  235.  
  236.           case CURSOR_LEFT:
  237.             refresh_mode = REFRESH_CONTENTS;
  238.             line_offset = -3;
  239.           break;
  240.  
  241.           case CURSOR_RIGHT:
  242.             refresh_mode = REFRESH_CONTENTS;
  243.             line_offset = 3;
  244.           break;
  245.  
  246.           case CURSOR_UP:
  247.             refresh_mode = REFRESH_CONTENTS;
  248.             page_offset = SCROLL_UP;
  249.           break;
  250.  
  251.           case CNTL_CURSOR_LEFT:
  252.             refresh_mode = REFRESH_TOP;
  253.             col_offset = -3;
  254.           break;
  255.  
  256.           case CNTL_CURSOR_RIGHT:
  257.             refresh_mode = REFRESH_TOP;
  258.             col_offset = 3;
  259.           break;
  260.  
  261.           case CNTL_PGUP:
  262.             refresh_mode = REFRESH_TOP;
  263.             row_offset = -1;
  264.           break;
  265.  
  266.           case CNTL_PGDN:
  267.             refresh_mode = REFRESH_TOP;
  268.             row_offset = 1;
  269.           break;
  270.  
  271.           case CNTL_HOME:
  272.             view_tile();
  273.             height_offset = view_rows;
  274.             width_offset = view_cols;
  275.           break;
  276.  
  277.           case CNTL_END:
  278.             view_tile();
  279.           break;
  280.  
  281.           case PGDN:
  282.             refresh_mode = REFRESH_CONTENTS;
  283.             page_offset = SCROLL_PAGE_DOWN;
  284.           break;
  285.  
  286.           case PGUP:
  287.             refresh_mode = REFRESH_CONTENTS;
  288.             page_offset = SCROLL_PAGE_UP;
  289.           break;
  290.  
  291.           case HOME:
  292.             refresh_mode = REFRESH_CONTENTS;
  293.             page_offset  = SCROLL_HOME;
  294.           break;
  295.  
  296.           case END:
  297.             refresh_mode = REFRESH_CONTENTS;
  298.             page_offset  = SCROLL_END;
  299.           break;
  300.  
  301.           case SHIFT_TAB:
  302.             view_refresh(REFRESH_PREV);
  303.             page_offset  = SCROLL_RESET;
  304.           break;
  305.  
  306.           default:
  307.           continue;
  308.           }
  309.       break;
  310.  
  311.       case 'e':
  312.       case 'E':
  313.          view_refresh(REFRESH_OFF);
  314.  
  315.          if (view_rows < 43)
  316.            {
  317.            _asm
  318.               {
  319.               push es
  320.               mov  ax,40H
  321.               mov  es,ax
  322.               push es:[87H]
  323.               or   byte ptr es:[87H],1
  324.  
  325.               mov  ax,1112H
  326.               xor  bx,bx
  327.               int  10h
  328.  
  329.               pop  es:[87H]
  330.               pop  es
  331.  
  332.               mov  ax,1200H
  333.               mov  bx,0020H
  334.               int  10h
  335.               }
  336.             }
  337.           else
  338.             {
  339.             _asm
  340.                {
  341.                push es
  342.                mov  ax,40H
  343.                mov  es,ax
  344.                push es:[87H]
  345.                or   byte ptr es:[87H],1
  346.  
  347.                mov ax,1111H
  348.                xor bx,bx
  349.                int 10h
  350.  
  351.                pop  es:[87H]
  352.                pop  es
  353.                }
  354.             }
  355.  
  356.          view_rows = (*bios_rows)+1;
  357.          view_cols = (*bios_cols);
  358.          view_tile();
  359.          refresh_mode = REFRESH_ALL;
  360.       break;
  361.  
  362.  
  363.       case 'w':
  364.         refresh_mode = REFRESH_TOP;
  365.         width_offset = -3;
  366.       break;
  367.  
  368.       case 'W':
  369.         refresh_mode = REFRESH_TOP;
  370.         width_offset = 3;
  371.       break;
  372.  
  373.       case 'h':
  374.         refresh_mode = REFRESH_TOP;
  375.         height_offset = -3;
  376.       break;
  377.  
  378.       case 'H':
  379.         refresh_mode = REFRESH_TOP;
  380.         height_offset = 3;
  381.       break;
  382.  
  383.       case 'C':
  384.       case 'c':
  385.         view_new(viewstack->prev->vf->fname,viewstack->prev->row,viewstack->prev->col,viewstack->prev->rows,viewstack->prev->cols);
  386.         view_tile();
  387.         page_offset  = SCROLL_RESET;
  388.       break;
  389.  
  390. #if VIEW_HAS_GOTO
  391.       case 'g':
  392.       case 'G':
  393.         refresh_mode = REFRESH_CONTENTS;
  394.         page_offset  = SCROLL_RESET;
  395.         view_goto_line();
  396.       break;
  397. #endif
  398.  
  399. #if VIEW_HAS_SEARCH
  400.       case 'S':
  401.       case 's':
  402.         refresh_mode = REFRESH_CONTENTS;
  403.         page_offset  = SCROLL_RESET;
  404.         view_search();
  405.       break;
  406. #endif
  407.  
  408.  
  409. #if VIEW_HAS_NEWFILE
  410.       case 'F':
  411.       case 'f':
  412.         if (!view_newfile()) continue;
  413.         view_tile();
  414.         page_offset = SCROLL_RESET;
  415.       break;
  416. #endif
  417.  
  418.       case 'D':
  419.       case 'd':
  420.         view_delete();
  421.         view_tile();
  422.       break;
  423.  
  424. #if VIEW_HAS_RAW
  425.       case 'X':
  426.       case 'x':
  427.         viewstack->prev->vf->lmode = VIEW_HEX_MODE;
  428.         page_offset = SCROLL_RESET;
  429.       break;
  430.  
  431.       case 'B':
  432.       case 'b':
  433.         viewstack->prev->vf->lmode = VIEW_BIN_MODE;
  434.         page_offset = SCROLL_RESET;
  435.       break;
  436. #endif
  437.  
  438.       case TAB:
  439.         view_refresh(REFRESH_NEXT);
  440.         page_offset  = SCROLL_RESET;
  441.       break;
  442.  
  443.       case ESC:
  444.         view_quit();
  445.       break;
  446.  
  447.       default:
  448.       continue;
  449.       }
  450.  
  451.     top       = viewstack->prev;
  452.     top->row  += row_offset;
  453.     top->col  += col_offset;
  454.     top->coff += line_offset;
  455.     top->rows += height_offset;
  456.     top->cols += width_offset;
  457.  
  458.     view_scroll(top,page_offset);
  459.     view_refresh(refresh_mode);
  460.     }
  461. } 
  462.  
  463. void view_scroll( VIEW *current, int mode )
  464. {
  465.    int      i;
  466.    VIEWFILE *vf;
  467.    ULONG    *pos;
  468.    UCHAR    **lines;
  469.  
  470.    if (kbhit())
  471.      if (!getch()) getch();
  472.  
  473.    vf    = current->vf;
  474.    pos   = current->pos;
  475.    lines = current->lines;
  476.  
  477.    switch( mode )
  478.      {
  479.      case SCROLL_NONE     :
  480.      return;
  481.  
  482.      case SCROLL_DOWN     :
  483.        if (lines[0])
  484.          {
  485.          view_seek(vf,pos[(VIEW_LINE_VIEW-1)],SEEK_SET);
  486.          view_getl_fwd(vf,view_line,VIEW_MAX_LINE);
  487.  
  488.          memmove(pos,pos+1,(VIEW_LINE_VIEW-1)*sizeof(ULONG));
  489.  
  490.          if (lines[0]) free(lines[0]);
  491.  
  492.          memmove(lines,lines+1,(VIEW_LINE_VIEW-1)*sizeof(UCHAR *));
  493.  
  494.          pos[(VIEW_LINE_VIEW-1)] = view_tell(vf);
  495.  
  496.          if (!view_getl_fwd(vf,view_line,VIEW_MAX_LINE))
  497.            lines[(VIEW_LINE_VIEW-1)] = view_strdup(view_line);
  498.          else
  499.            {
  500.            lines[(VIEW_LINE_VIEW-1)] = NULL;
  501.            pos[(VIEW_LINE_VIEW-1)]   = LONG_MAX;
  502.            }
  503.          }
  504.      break;
  505.  
  506.  
  507.      case SCROLL_UP       :
  508.        if (pos[0])
  509.          {
  510.          view_seek(vf,pos[0],SEEK_SET);
  511.  
  512.          memmove(pos+1,pos,(VIEW_LINE_VIEW-1)*sizeof(ULONG));
  513.  
  514.          if (lines[(VIEW_LINE_VIEW-1)]) free(lines[(VIEW_LINE_VIEW-1)]);
  515.                     
  516.          memmove(lines+1,lines,(VIEW_LINE_VIEW-1)*sizeof(UCHAR *));
  517.  
  518.          view_getl_bwd(vf,view_line,VIEW_MAX_LINE);
  519.  
  520.          pos[0] = view_tell(vf);
  521.  
  522.          view_getl_fwd(vf,view_line,VIEW_MAX_LINE);
  523.  
  524.          lines[0] = view_strdup(view_line);
  525.          }
  526.      break;
  527.  
  528.      case SCROLL_PAGE_UP  :
  529.        for (i = 0; i < (current->rows-2); i++)
  530.          view_scroll(current,SCROLL_UP);
  531.      break;
  532.  
  533.      case SCROLL_PAGE_DOWN:
  534.        for (i = 0; i < (current->rows-2); i++)
  535.          view_scroll(current,SCROLL_DOWN);
  536.      break;
  537.  
  538.      case SCROLL_HOME     :
  539.        view_seek(vf,0L,SEEK_SET);
  540.        view_scroll(current,SCROLL_RESET);
  541.      break;
  542.  
  543.      case SCROLL_END      :
  544.        view_seek(vf,0L,SEEK_END);
  545.        view_scroll(current,SCROLL_RESET);
  546.        view_scroll(current,SCROLL_PAGE_UP);
  547.      break;
  548.  
  549.      case SCROLL_CLEAR    :
  550.        for (i = 0; i < VIEW_LINE_VIEW; i ++)
  551.          {
  552.          pos[i] = LONG_MAX;
  553.          if (lines[i])
  554.            {
  555.            free(lines[i]);
  556.            lines[i] = NULL;
  557.            }
  558.          }
  559.  
  560.        return;
  561.      break;
  562.  
  563.      case SCROLL_RESET    :
  564.  
  565.        view_scroll(current,SCROLL_CLEAR);
  566.  
  567.        for (i = 0; i < VIEW_LINE_VIEW; i ++ )
  568.          {
  569.          pos[i] = view_tell(vf);
  570.          if (!view_getl_fwd(vf,view_line,VIEW_MAX_LINE))
  571.            lines[i] = view_strdup(view_line);
  572.          else
  573.            break;
  574.          }
  575.      break;
  576.      }
  577.  
  578.   view_seek(vf,pos[0],SEEK_SET);
  579. }
  580.  
  581.  
  582. void view_new( UCHAR *fname, int row,int col,int rows,int cols )
  583. {
  584.   VIEW *new;
  585.   int th;
  586.  
  587.   if (!strcmp(fname,"Standard Input")) return;
  588.  
  589.   new = (VIEW *)malloc(sizeof(VIEW));
  590.   if (!new) view_error(1,"VIEW0003");
  591.  
  592.   if (!(new->vf = view_open(fname)))
  593.     {
  594.     free(new);
  595.     return;
  596.     }
  597.  
  598.   new->row  = row;
  599.   new->col  = col;
  600.   new->rows = rows;
  601.   new->cols = cols;
  602.   memset(new->pos,'\0',VIEW_LINE_VIEW*sizeof(ULONG));
  603.   memset(new->lines,'\0',VIEW_LINE_VIEW*sizeof(UCHAR *));
  604.   new->coff = 0;
  605.   new->save = NULL;
  606.  
  607.  
  608.   if (viewstack == NULL)
  609.     {
  610.     new->next = new;
  611.     new->prev = new;
  612.     viewstack = new;
  613.     }
  614.   else
  615.     {
  616.     new->next = viewstack;
  617.     new->prev = viewstack->prev;
  618.     viewstack->prev->next = new;
  619.     viewstack->prev = new;
  620.     }
  621. }
  622.  
  623. void view_restore( VIEW *trav )
  624. {
  625.    view_putsave(trav->save);
  626.    trav->save = NULL;
  627. }
  628.  
  629. void view_save( VIEW *trav )
  630. {
  631.    trav->save = view_getsave(trav->row,trav->col,trav->rows,trav->cols);
  632. }
  633.  
  634. void view_refresh(int refresh_mode)
  635. {
  636.    VIEW *trav;
  637.    int  r;
  638.    int  blank;
  639.    UCHAR _far *oscreen;
  640.  
  641.    if (refresh_mode != REFRESH_CONTENTS && refresh_mode != REFRESH_TOP)
  642.      {
  643.      oscreen = screen;
  644.  
  645.      screen = malloc(view_rows*(view_cols*2));
  646.      if (!screen)
  647.        {
  648.        screen = oscreen;
  649.        }
  650.      else
  651.        {
  652.        memmove(screen,oscreen,view_rows*(view_cols*2));
  653.        }
  654.      }
  655.  
  656.    if (refresh_mode != REFRESH_CONTENTS)
  657.      {
  658.      trav = viewstack->prev;
  659.  
  660.      do
  661.        {
  662.        if (trav->save)
  663.          view_restore(trav);
  664.      
  665.        trav = trav->prev;
  666.  
  667.        if (refresh_mode == REFRESH_CONTENTS || refresh_mode == REFRESH_TOP) break;
  668.        }
  669.      while(trav != viewstack->prev);
  670.      }
  671.  
  672.    if (refresh_mode == REFRESH_NEXT)
  673.      {
  674.      viewstack = viewstack->next;
  675.      refresh_mode = REFRESH_ALL;
  676.      }
  677.  
  678.    if (refresh_mode == REFRESH_PREV)
  679.      {
  680.      viewstack = viewstack->prev;
  681.      refresh_mode = REFRESH_ALL;
  682.      }
  683.  
  684.    if (refresh_mode != REFRESH_OFF) 
  685.      {
  686.      if (refresh_mode != REFRESH_ALL)
  687.        trav = viewstack->prev;
  688.      else
  689.        trav = viewstack;
  690.  
  691.      do 
  692.        {
  693.        if (trav == viewstack->prev)
  694.          view_attr = ACTIVE_WINDOW;
  695.        else
  696.          view_attr = INACTIVE_WINDOW;
  697.  
  698.        trav->rows = max(trav->rows,3);
  699.        trav->rows = min(trav->rows,view_rows);
  700.        trav->cols = max(trav->cols,3);
  701.        trav->cols = min(trav->cols,view_cols);
  702.  
  703.        trav->col  = max(trav->col,0);
  704.        trav->col  = min(trav->col,view_cols-trav->cols);
  705.  
  706.        trav->row  = max(trav->row,0);
  707.        trav->row  = min(trav->row,view_rows-trav->rows);
  708.                                
  709.        trav->coff = max(trav->coff,0);
  710.  
  711.        if (refresh_mode != REFRESH_CONTENTS)
  712.          {
  713.          view_save(trav);
  714.          view_frame(trav->vf->fname,trav->row,trav->col,trav->rows,trav->cols);
  715.          }
  716.  
  717.        for (r = 1; r < trav->rows-1; r ++)
  718.          {
  719.          blank = TRUE;
  720.          view_goto(trav->row+r,trav->col+1);
  721.  
  722.          if (trav->lines[r-1] && (strlen(trav->lines[r-1]) > trav->coff))
  723.            {
  724.            view_puts(trav->lines[r-1]+trav->coff,trav->cols-2);
  725.            blank = FALSE;
  726.            }
  727.  
  728.          if (blank) view_fill(' ',trav->cols-2);
  729.          }
  730.  
  731.        trav = trav->next;
  732.  
  733.        if (refresh_mode != REFRESH_ALL) break;
  734.        } 
  735.      while(trav != viewstack);
  736.      }
  737.  
  738.    if (refresh_mode == REFRESH_ALL || refresh_mode == REFRESH_OFF)
  739.      {
  740.      if (screen != oscreen)
  741.        {
  742.        memmove(oscreen,screen,view_rows*(view_cols*2));
  743.        free(screen);
  744.        screen = oscreen;
  745.        }
  746.      }
  747. }
  748.  
  749. void view_quit( void )
  750. {
  751.   for(;;) view_delete();
  752. }
  753.  
  754. void view_tile( void )
  755. {
  756. #if VIEW_HAS_TILE
  757.  
  758.   VIEW *trav;
  759.   int windows;
  760.   int vsize,hsize;
  761.   int row,col;
  762.  
  763.   if (!viewstack) return;
  764.  
  765.   windows = 0;
  766.   trav    = viewstack;
  767.  
  768.   do
  769.     {
  770.     windows ++;
  771.     trav = trav->next;
  772.     }
  773.   while (trav != viewstack);
  774.  
  775.   hsize = view_cols;
  776.   vsize = view_rows;
  777.  
  778.   while ( (view_cols/hsize)*(view_rows/vsize) < windows )
  779.     vsize --;
  780.  
  781.   if (vsize < 3)
  782.     {
  783.     vsize = view_rows;
  784.     while ( (view_cols/hsize)*(view_rows/vsize) < windows )
  785.       hsize --;
  786.     }
  787.  
  788.   if (hsize < 10)
  789.     {
  790.     hsize = view_cols;
  791.     vsize = 24;
  792.  
  793.     while ( (view_cols/hsize)*(view_rows/vsize) < windows )
  794.       {
  795.       hsize -= 3;
  796.       vsize --;
  797.       }
  798.     }
  799.     
  800.   trav = viewstack;
  801.   row  = 0;
  802.   col  = 0;
  803.  
  804.   do
  805.     {
  806.     trav->row = row;
  807.     trav->col = col;
  808.     trav->rows = vsize;
  809.     trav->cols = hsize;
  810.  
  811.     col += hsize;
  812.     if (col+hsize > view_cols)
  813.       {
  814.       col = 0;
  815.       row += vsize;
  816.       }
  817.     trav = trav->next;
  818.     }
  819.   while(trav != viewstack);
  820.  
  821. #endif /* VIEW_HAS_TILE */
  822. }
  823.   
  824. void view_delete( void )
  825. {
  826.    VIEW *hold;
  827.    int lets_exit = FALSE;
  828.    
  829.  
  830.    if (viewstack->prev == viewstack)
  831.      lets_exit = TRUE;
  832.  
  833.    hold = viewstack->prev;
  834.    viewstack->prev->prev->next = viewstack;
  835.    viewstack->prev = viewstack->prev->prev;
  836.    view_restore(hold);
  837.    view_scroll(hold,SCROLL_CLEAR);
  838.    view_close(hold->vf);
  839.    free(hold);
  840.  
  841.    if (lets_exit) 
  842.      {
  843.      if (view_line) free(view_line);
  844.  
  845. #if VIEW_HAS_DIR
  846.      if (view_curdir)
  847.        {
  848.        _dos_setdrive(view_curdrive,&lets_exit);
  849.        chdir(view_curdir);
  850.        free(view_curdir);
  851.        }
  852. #endif
  853.      exit(0);
  854.      }
  855. }
  856.  
  857. #if VIEW_HAS_NEWFILE
  858. int view_newfile( void )
  859. {
  860.   int c1,c2;
  861.   char fname[80];
  862.  
  863.   fname[0] = '\0';
  864.  
  865.   do
  866.     {
  867.     c1 = view_prompt("New File","Filename:",fname,40);
  868.  
  869. #if VIEW_HAS_DIR
  870.     if (c1 && !strlen(fname))
  871.       c1 = view_dir(fname);
  872. #endif
  873.  
  874.     if (c1 && (c2 = (access(fname,0)
  875. #if VIEW_HAS_MEMORY
  876.     && stricmp(fname,VIEW_MEM_NAME)
  877. #endif
  878.     ))) 
  879.       {
  880.       strcpy(fname,"File Not Found");
  881.       }
  882.     }
  883.   while(c1 && c2);
  884.  
  885.   if (c1)
  886.     {
  887.     view_new(fname,0,0,16,45);
  888.     return(TRUE);
  889.     }
  890.   else
  891.     return(FALSE);
  892. }
  893. #endif /* VIEW_HAS_NEWFILE */
  894.  
  895. #if VIEW_HAS_SEARCH
  896. int view_search( void )
  897. {
  898.   int c1,c2;
  899.   char pat[80];
  900.   UCHAR *found;
  901.   ULONG pos;
  902.   int ret;
  903.   VIEWFILE *vf;
  904.  
  905.   vf = viewstack->prev->vf;
  906.  
  907.  
  908.   pat[0] = '\0';
  909.  
  910.   do
  911.     {
  912.     c1 = view_prompt("Search","Pattern:",pat,40);
  913.  
  914.     if (c1)
  915.       {
  916.       view_seek(vf,viewstack->prev->pos[0],SEEK_SET);
  917.  
  918.       ret   = 0;
  919.       found = NULL;
  920.  
  921.       while(!ret && !found)
  922.         {
  923.         pos = view_tell(vf);
  924.         ret = view_getl_fwd(vf,view_line,VIEW_MAX_LINE);
  925.         if (!ret) found = strstr(view_line,pat);
  926.         }
  927.  
  928.       if (found)
  929.         {
  930.         view_seek(vf,pos,SEEK_SET);
  931.         viewstack->prev->coff = found-view_line;
  932.         return(TRUE);
  933.         }
  934.       else
  935.         strcpy(pat,"Pattern Not Found");
  936.       }
  937.     }
  938.   while(c1);
  939.  
  940.   return(FALSE);
  941. }
  942. #endif
  943.  
  944.  
  945. #if VIEW_HAS_GOTO
  946. void view_goto_line( void )
  947. {
  948.   int c1;
  949.   char pat[80];
  950.   ULONG pos;
  951.   int ret;
  952.   VIEWFILE *vf;
  953.   UCHAR *goto_pmt[] = {"Offset In File:","Memory Address (SSSSOOOO):","Line Number:"};
  954.   int   goto_len[]  = { 10, 8, 8 };
  955.   int   goto_base[] = { 10,16,10 };
  956.   int   goto_type;
  957.  
  958.   pat[0] = '\0';
  959.   vf = viewstack->prev->vf;
  960.  
  961.  
  962. #if VIEW_HAS_RAW
  963.   if (vf->lmode 
  964.  
  965. #if VIEW_HAS_MEMORY
  966.   && vf->fh != VIEW_MEM_HDL
  967. #endif
  968.  
  969.   )
  970.     goto_type = 0;
  971.  
  972. #if VIEW_HAS_MEMORY
  973.   else if (vf->lmode  && vf->fh == VIEW_MEM_HDL )
  974.     goto_type = 1;
  975. #endif
  976.  
  977.   else
  978. #endif /* VIEW_HAS_RAW */
  979.     goto_type = 2;
  980.  
  981.   c1 = view_prompt("Goto",goto_pmt[goto_type],pat,goto_len[goto_type]);
  982.  
  983.   if (c1)  
  984.     {  
  985.     pos = view_atoul(pat,goto_base[goto_type]);  
  986.  
  987.  
  988.     switch(goto_type)  
  989.       {  
  990. #if VIEW_HAS_RAW
  991.       case 0:  
  992.         view_seek(vf,pos,SEEK_SET);  
  993.       break;  
  994. #endif
  995.  
  996. #if VIEW_HAS_MEMORY
  997.       case 1:  
  998.         view_seek(vf,(ULONG)(((UCHAR _huge *)pos)-memory),SEEK_SET);  
  999.       break;  
  1000. #endif
  1001.  
  1002.       case 2:  
  1003.         view_seek(vf,0L,SEEK_SET);  
  1004.  
  1005.         ret = 0;
  1006.         while (!ret && pos)  
  1007.           {  
  1008.           ret = view_getl_fwd(vf,view_line,VIEW_MAX_LINE);  
  1009.           pos --;  
  1010.           }  
  1011.       break;  
  1012.       }  
  1013.     }  
  1014. }
  1015. #endif /* VIEW_HAS_GOTO */
  1016.  
  1017. void _far view_errfunc( void )
  1018. { 
  1019.   _hardresume(_HARDERR_FAIL);
  1020. }
  1021.  
  1022. UCHAR *view_strdup( UCHAR *str )
  1023. {
  1024.    str = strdup(str);
  1025.  
  1026.    if (!str)
  1027.      view_error(1,"VIEW0010");
  1028.  
  1029.    return(str);
  1030. }
  1031.